home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / TERMINAL / SRCS / SCRIPT.C < prev    next >
Text File  |  1990-11-20  |  13KB  |  546 lines
  1. /*
  2.     Terminal 2.0
  3.     "Script.c"
  4. */
  5.  
  6. #ifdef THINK_C
  7. #include "MacHeaders"
  8. #endif
  9. #ifdef applec
  10. #pragma load ":(Objects):MacHeadersMPW"
  11. #pragma segment Main2
  12. #endif
  13.  
  14. #include "Interp.h"
  15. #include "Text.h"
  16. #include "Main.h"
  17. #include "Document.h"
  18. #include "Procedure.h"
  19. #include "File.h"
  20. #include "FormatStr.h"
  21. #include "Serial.h"
  22. #include "Macros.h"
  23. #include "Utilities.h"
  24.  
  25. /* ----- beep() -------------------------------------------------------- */
  26.  
  27. static INTEGER SI_beep(INTEGER params[])
  28. {
  29. #pragma unused(params)
  30.     SysBeep(1);
  31.     return 0;
  32. }
  33.  
  34. /* ----- result = pause(timeout) --------------------------------------- */
  35.  
  36. static INTEGER SI_pause(INTEGER params[])
  37. {
  38.     return (INTEGER)Loop((long)params[0], 0, 0);
  39. }
  40.  
  41. /* ----- result = prompt(string, timeout) ------------------------------ */
  42.  
  43. static INTEGER SI_prompt(INTEGER params[])
  44. {
  45.     register INTEGER result;
  46.     register Byte *s = (Byte *)params[0];
  47.  
  48.     CtoPstr((char *)s);
  49.     result = (INTEGER)Loop((long)params[1], s, 1);
  50.     PtoCstr((char *)s);
  51.     return result;
  52. }
  53.  
  54. /* ----- result = nextline(string, timeout) ---------------------------- */
  55.  
  56. static INTEGER SI_nextline(INTEGER params[])
  57. {
  58.     register INTEGER result;
  59.     register Byte *s = (Byte *)params[0];
  60.  
  61.     result = (INTEGER)Loop((long)params[1], s, 2);
  62.     PtoCstr((char *)s);
  63.     return result;
  64. }
  65.  
  66. /* ----- result = type(template, ...) ---------------------------------- */
  67.  
  68. static INTEGER SI_type(INTEGER params[])
  69. {
  70.     register INTEGER result;
  71.     Byte s[256];
  72.  
  73.     if (params[0]) {
  74.         SFormatStr(s, (Byte *)params[0], ¶ms[1]);
  75.         result = Type(s);
  76.     } else {            /* No formatting */
  77.         CtoPstr((char *)params[1]);
  78.         result = Type((Byte *)params[1]);
  79.         PtoCstr((char *)params[1]);
  80.     }
  81.     return result;
  82. }
  83.  
  84. /* ----- result = display(template, ...) ------------------------------- */
  85.  
  86. static INTEGER SI_display(INTEGER params[])
  87. {
  88.     register INTEGER result;
  89.     Byte s[256];
  90.  
  91.     if (params[0]) {
  92.         SFormatStr(s, (Byte *)params[0], ¶ms[1]);
  93.         result = Display(s);
  94.     } else {            /* No formatting */
  95.         CtoPstr((char *)params[1]);
  96.         result = Display((Byte *)params[1]);
  97.         PtoCstr((char *)params[1]);
  98.     }
  99.     return result;
  100. }
  101.  
  102. /* ----- format(string, template, ...) --------------------------------- */
  103.  
  104. static INTEGER SI_format(INTEGER params[])
  105. {
  106.     SFormatStr((Byte *)params[0], (Byte *)params[1], ¶ms[2]);
  107.     PtoCstr((char *)params[0]);
  108.     return 0;
  109. }
  110.  
  111. /* ----- result = setup(baud,data,parity,stop,port,dtr,handshake) ------ */
  112.  
  113. static INTEGER SI_setup(INTEGER params[])
  114. {
  115.     INTEGER err;
  116.     register INTEGER port = params[4];
  117.     register Boolean newport;
  118.  
  119.     if (newport = (port != -1 && port != 0 && port != 1))
  120.         CtoPstr((char *)port);
  121.     else
  122.         port = 0;
  123.     err = (INTEGER)PortSetUp((short)params[0], (short)params[1],
  124.         (short)params[2], (short)params[3], (Byte *)port,
  125.         (short)params[5], (short)params[6]);
  126.     if (newport)
  127.         PtoCstr((char *)port);
  128.     return err;
  129. }
  130.  
  131. /* ----- terminal(lEcho, rEcho, autoLF, save) -------------------------- */
  132.  
  133. static INTEGER SI_terminal(INTEGER params[])
  134. {
  135.     return (INTEGER)TerminalSetup((short)params[0], (short)params[1],
  136.         (short)params[2], (short)params[3]);
  137. }
  138.  
  139. /* ----- lecho(OnOff) -------------------------------------------------- */
  140.  
  141. static INTEGER SI_lecho(INTEGER params[])
  142. {
  143.     return (INTEGER)TerminalSetup((short)params[0], -1, -1, -1);
  144. }
  145.  
  146. /* ----- recho(OnOff) -------------------------------------------------- */
  147.  
  148. static INTEGER SI_recho(INTEGER params[])
  149. {
  150.     return (INTEGER)TerminalSetup(-1, (short)params[0], -1, -1);
  151. }
  152.  
  153. /* ----- autolf(OnOff) ------------------------------------------------- */
  154.  
  155. static INTEGER SI_autolf(INTEGER params[])
  156. {
  157.     return (INTEGER)TerminalSetup(-1, -1, (short)params[0], -1);
  158. }
  159.  
  160. /* ----- save(OnOff) --------------------------------------------------- */
  161.  
  162. static INTEGER SI_save(INTEGER params[])
  163. {
  164.     return (INTEGER)TerminalSetup(-1, -1, -1, (short)params[0]);
  165. }
  166.  
  167. /* ----- result = send(name) ------------------------------------------- */
  168.  
  169. static INTEGER SI_send(INTEGER params[])
  170. {
  171.     register INTEGER result;
  172.     register Byte name[256];
  173.     short volume;
  174.     long directory;
  175.     OSType creator, type;
  176.     long create, modif;
  177.     short ref;
  178.  
  179.     /* Use default folder */
  180.  
  181.     Folder(&volume, &directory);
  182.     CtoPstr((char *)params[0]);
  183.     memcpy(name, (Byte *)params[0], *((Byte *)params[0]) + 1);
  184.     PtoCstr((char *)params[0]);
  185.  
  186.     /* See if this is a TEXT file */
  187.  
  188.     if (result = (INTEGER)InfoFile(volume, directory, name,
  189.             &creator, &type, &create, &modif))
  190.         goto done;
  191.     if (type != TEXT) {
  192.         result = 3;
  193.         goto done;
  194.     }
  195.  
  196.     /* Open the file, send it */
  197.  
  198.     if (!(result = (INTEGER)OpenFile(volume, directory, name, &ref)))
  199.         result = (INTEGER)SendTextFile(ref, name);
  200.  
  201. done:
  202.     return result;
  203. }
  204.  
  205. /* ----- result = download(name, binary, zmodem) ----------------------- */
  206.  
  207. static INTEGER SI_download(INTEGER params[])
  208. {
  209.     register INTEGER result;
  210.     register Byte *name = (Byte *)params[0];
  211.  
  212.     if (name)
  213.         CtoPstr((char *)name);
  214.     result = Download(name, params[1], params[2]);
  215.     if (name)
  216.         PtoCstr((char *)name);
  217.     return result;
  218. }
  219.  
  220. /* ----- result = upload(name, binary, zmodem) ------------------------- */
  221.  
  222. static INTEGER SI_upload(INTEGER params[])
  223. {
  224.     register INTEGER result;
  225.  
  226.     CtoPstr((char *)params[0]);
  227.     result = Upload((Byte *)params[0], params[1], params[2]);
  228.     PtoCstr((char *)params[0]);
  229.     return result;
  230. }
  231.  
  232. /* ----- seconds = time() ---------------------------------------------- */
  233.  
  234. static INTEGER SI_time(INTEGER params[])
  235. {
  236. #pragma unused(params)
  237.     return Time;
  238. }
  239.  
  240. /* ----- date(seconds, &yr, &mo, &da, &ho, &mi, &se, &dw) -------------- */
  241.  
  242. static INTEGER SI_date(INTEGER params[])
  243. {
  244.     DateTimeRec r;
  245.  
  246.     Secs2Date(params[0], &r);
  247.     *(long *)params[1] = r.year;
  248.     *(long *)params[2] = r.month;
  249.     *(long *)params[3] = r.day;
  250.     *(long *)params[4] = r.hour;
  251.     *(long *)params[5] = r.minute;
  252.     *(long *)params[6] = r.second;
  253.     *(long *)params[7] = r.dayOfWeek;
  254.     return 0;
  255. }
  256.  
  257. /* ----- string = new(size) -------------------------------------------- */
  258.  
  259. static INTEGER SI_new(INTEGER params[])
  260. {
  261.     return (INTEGER)NewPtrClear(params[0]);
  262. }
  263.  
  264. /* ----- free(string) -------------------------------------------------- */
  265.  
  266. static INTEGER SI_free(INTEGER params[])
  267. {
  268.     DisposPtr((Ptr)params[0]);
  269.     return 0;
  270. }
  271.  
  272. /* ----- move(source, destination, count) ------------------------------ */
  273.  
  274. static INTEGER SI_move(INTEGER params[])
  275. {
  276.     memmove((void *)params[1], (void *)params[0], params[2]);
  277.     return 0;
  278. }
  279.  
  280. /* ----- result = strcmp(s1, s2) --------------------------------------- */
  281.  
  282. static INTEGER SI_strcmp(INTEGER params[])
  283. {
  284.     register Byte *s1 = (Byte *)params[0];
  285.     register Byte *s2 = (Byte *)params[1];
  286.  
  287.     while (tolower(*s1) == tolower(*s2)) {
  288.         if (!*s1)
  289.             break;
  290.         s1++;
  291.         s2++;
  292.     }
  293.     return (INTEGER)(tolower(*s1) - tolower(*s2));
  294. }
  295.  
  296. /* ----- result = catalog(i,name,&type,&dsize,&rsize,&cdate,&mdate) ---- */
  297.  
  298. static INTEGER SI_catalog(INTEGER params[])
  299. {
  300.     register short err;
  301.     HParamBlockRec p;
  302.     short volume;
  303.     long directory;
  304.  
  305.     if (params[0] == 0)        /* File name is given */
  306.         CtoPstr((char *)params[1]);
  307.     Folder(&volume, &directory);
  308.     memset(&p, 0, sizeof(p));
  309.     p.ioParam.ioVRefNum = volume;
  310.     p.fileParam.ioDirID = directory;
  311.     p.ioParam.ioNamePtr = (StringPtr)params[1];    /* File name */
  312.     p.fileParam.ioFDirIndex = params[0];        /* Index */
  313.     err = PBHGetFInfo(&p, FALSE);
  314.     PtoCstr((char *)params[1]);
  315.     if (err)
  316.         return err;
  317.     *((long *)params[2]) = p.fileParam.ioFlFndrInfo.fdType;    /* Type */
  318.     *((long *)params[3]) = p.fileParam.ioFlLgLen;    /* Data fork length */
  319.     *((long *)params[4]) = p.fileParam.ioFlRLgLen;    /* Resource fork */
  320.     *((long *)params[5]) = p.fileParam.ioFlCrDat;    /* Creation date */
  321.     *((long *)params[6]) = p.fileParam.ioFlMdDat;    /* Modification date */
  322.     return 0;
  323. }
  324.  
  325. /* ----- result = getcts() --------------------------------------------- */
  326.  
  327. static INTEGER SI_getcts(INTEGER params[])
  328. {
  329. #pragma unused(params)
  330.     return SerialCTS();
  331. }
  332.  
  333. /* ----- result = getdcd() --------------------------------------------- */
  334.  
  335. static INTEGER SI_getdcd(INTEGER params[])
  336. {
  337. #pragma unused(params)
  338.     return SerialDCD();
  339. }
  340.  
  341. /* ----- setdtr(onoff) ------------------------------------------------- */
  342.  
  343. static INTEGER SI_setdtr(INTEGER params[])
  344. {
  345.     SerialDTR(params[0]);
  346.     return 0;
  347. }
  348.  
  349. /* ----- protocol(crc, k, batch, timeout, binary, b) ------------------- */
  350.  
  351. static INTEGER SI_protocol(INTEGER params[])
  352. {
  353.     return TransferSetup(params[0] != 0, params[1] != 0, params[2] != 0,
  354.         params[3] != 0);
  355. }
  356.  
  357. /* ----- xyparms(crc, k, batch, timeout) ------------------------------- */
  358.  
  359. static INTEGER SI_xyparms(INTEGER params[])
  360. {
  361.     return XYModemSetup(params[0] != 0, params[1], params[2], params[3]);
  362. }
  363.  
  364. /* ----- zparms(escctl,timeout,retries,buffer,packet,window,crcq) -----  */
  365.  
  366. static INTEGER SI_zparms(INTEGER params[])
  367. {
  368.     return ZModemSetup(params[0] != 0, params[1], params[2], params[3],
  369.         params[4], params[5], params[6]);
  370. }
  371.  
  372. /* ----- err = macrol(name) -------------------------------------------- */
  373.  
  374. static INTEGER SI_macrol(INTEGER params[])    /* Load macro file */
  375. {
  376.     register short err;
  377.  
  378.     CtoPstr((char *)params[0]);
  379.     err = LoadMacros(Settings.scriptVolume, Settings.scriptDirectory,
  380.         (Byte *)params[0]);
  381.     PtoCstr((char *)params[0]);
  382.     return err;
  383. }
  384.  
  385. /* ----- err = macrox(i, op, name) ------------------------------------- */
  386.  
  387. static INTEGER SI_macrox(INTEGER params[])    /* Execute macro */
  388. {
  389.     switch (params[1]) {
  390.         case 0:    /* Send */
  391.         case 1:    /* Display */
  392.             break;
  393.         case 2:    /* Get name */
  394.             NameMacro(params[0] + DOMACRO1, (Byte *)params[2]);
  395.             PtoCstr((char *)params[2]);
  396.         default:
  397.         return 0;
  398.     }
  399.     return DoMacro(params[0] + DOMACRO1, params[1] != 0);
  400. }
  401.  
  402. /* ----- text(prompt, ldelay, cdelay) ---------------------------------- */
  403.  
  404. static INTEGER SI_text(INTEGER params[])
  405. {
  406.     return TextsendSetup((params[0] < 0) ? 0 : (Byte *)params[0],
  407.         params[1], params[2]);
  408. }
  409.  
  410. /* ----- i = val(str) -------------------------------------------------- */
  411.  
  412. static INTEGER SI_val(INTEGER params[])    /* Convert string to integer */
  413. {
  414.     INTEGER i;
  415.  
  416.     CtoPstr((char *)params[0]);
  417.     StringToNum((Byte *)params[0], &i);
  418.     PtoCstr((char *)params[0]);
  419.     return i;
  420. }
  421.  
  422. /* ----- err = capture(onoff, name) ------------------------------------ */
  423.  
  424. static INTEGER SI_capture(INTEGER params[])    /* Capture file on/off */
  425. {
  426.     register DocumentPeek window = TerminalWindow;
  427.     register short err;
  428.     register Byte *name;
  429.     short volume;
  430.     long directory;
  431.     short r;
  432.     OSType creator, type;
  433.     long create, modif;
  434.  
  435.     Folder(&volume, &directory);
  436.     name = (Byte *)params[1];
  437.     switch (params[0]) {
  438.         case 0:                /* Capture off */
  439.             if (!window->file)
  440.                 return 1;    /* Was not open */
  441.             err = (window->length) ?
  442.                 FSWrite(window->file, &window->length, window->record) : 0;
  443.             FSClose(window->file);
  444.             FlushVol(0, window->volume);
  445.             window->file = window->volume = 0;
  446.             window->length = 0;
  447.             SetItemStyle(GetMenu(FILE), CAPTURE, 0);
  448.             return err;
  449.         case 1:                /* Capture on, new file */
  450.             if (window->file)
  451.                 return 2;    /* Still on */
  452.             CtoPstr((char *)name);
  453.             DeleteFile(volume, directory, name);
  454.             if (!(err = CreateFile(volume, directory, name,
  455.                         Settings.textCreator, TEXT)) &&
  456.                     !(err = OpenFile(volume, directory, name, &r))) {
  457.                 window->file = r;
  458.                 window->volume = volume;
  459.                 SetItemStyle(GetMenu(FILE), CAPTURE, ACTIVE);
  460.             }
  461.             PtoCstr((char *)name);
  462.             return err;
  463.         case 2:                /* Capture on, append */
  464.             if (window->file)
  465.                 return 2;    /* Still on */
  466.             CtoPstr((char *)name);
  467.             if (err = InfoFile(volume, directory, name,
  468.                     &creator, &type, &create, &modif)) {
  469.                 /* File does not yet exist */
  470.                 if ((err = CreateFile(volume, directory, name,
  471.                             Settings.textCreator, TEXT)) ||
  472.                         (err = OpenFile(volume, directory, name, &r)))
  473.                     goto back;
  474.             } else {
  475.                 /* File already exists */
  476.                 if (type != TEXT) {
  477.                     err = 3;    /* Must be a TEXT file */
  478.                     goto back;
  479.                 }
  480.                 if (err = OpenFile(volume, directory, name, &r))
  481.                     goto back;
  482.                 if (err = SetFPos(r, fsFromLEOF, 0)) {
  483.                     FSClose(r);
  484.                     goto back;
  485.                 }
  486.             }
  487.             window->file = r;
  488.             window->volume = volume;
  489.             SetItemStyle(GetMenu(FILE), CAPTURE, ACTIVE);
  490. back:
  491.             PtoCstr((char *)name);
  492.             return err;
  493.         default:            /* Illegal parameter */
  494.             return 9;
  495.     }
  496. }
  497.  
  498. /* ----- err = nextbuff(char *buff, int count, int timeout) ------------ */
  499.  
  500. static INTEGER SI_nextbuff(INTEGER params[])
  501. {
  502.     return (INTEGER)LoopBuffer((long)params[2],(Byte *)params[0],params[1]);
  503. }
  504.  
  505. /* ----- Script intrinsic functions ------------------------------------ */
  506.  
  507. INTRINSIC Intrinsics[] = {
  508.     (Byte *)"autolf",    SI_autolf,
  509.     (Byte *)"beep",        SI_beep,
  510.     (Byte *)"capture",    SI_capture,
  511.     (Byte *)"catalog",    SI_catalog,
  512.     (Byte *)"date",        SI_date,
  513.     (Byte *)"display",    SI_display,
  514.     (Byte *)"download",    SI_download,
  515.     (Byte *)"format",    SI_format,
  516.     (Byte *)"free",        SI_free,
  517.     (Byte *)"getcts",    SI_getcts,
  518.     (Byte *)"getdcd",    SI_getdcd,
  519.     (Byte *)"lecho",    SI_lecho,
  520.     (Byte *)"macrol",    SI_macrol,
  521.     (Byte *)"macrox",    SI_macrox,
  522.     (Byte *)"move",        SI_move,
  523.     (Byte *)"new",        SI_new,
  524.     (Byte *)"nextbuff",    SI_nextbuff,
  525.     (Byte *)"nextline",    SI_nextline,
  526.     (Byte *)"pause",    SI_pause,
  527.     (Byte *)"prompt",    SI_prompt,
  528.     (Byte *)"protocol",    SI_protocol,
  529.     (Byte *)"recho",    SI_recho,
  530.     (Byte *)"save",        SI_save,
  531.     (Byte *)"send",        SI_send,
  532.     (Byte *)"setdtr",    SI_setdtr,
  533.     (Byte *)"setup",    SI_setup,
  534.     (Byte *)"stack",    SI_stack,        /* Defined in Interp.c */
  535.     (Byte *)"strcmp",    SI_strcmp,
  536.     (Byte *)"terminal",    SI_terminal,
  537.     (Byte *)"text",        SI_text,
  538.     (Byte *)"time",        SI_time,
  539.     (Byte *)"type",        SI_type,
  540.     (Byte *)"upload",    SI_upload,
  541.     (Byte *)"val",        SI_val,
  542.     (Byte *)"xyparms",    SI_xyparms,
  543.     (Byte *)"zparms",    SI_zparms,
  544.     0,            0
  545. };
  546.